home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_xfig.idb / usr / freeware / src / xfig / transfig.3.1.2 / fig2dev / read.c.z / read.c
Encoding:
C/C++ Source or Header  |  1997-09-09  |  27.8 KB  |  1,114 lines
  1. /*
  2.  * TransFig: Facility for Translating Fig code
  3.  * Copyright (c) 1985 Supoj Sutantavibul
  4.  * Copyright (c) 1991 Micah Beck
  5.  *
  6.  * THE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  7.  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  8.  * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  9.  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  10.  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  11.  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  12.  * PERFORMANCE OF THIS SOFTWARE.
  13.  *
  14.  * The X Consortium, and any party obtaining a copy of these files from
  15.  * the X Consortium, directly or indirectly, is granted, free of charge, a
  16.  * full and unrestricted irrevocable, world-wide, paid up, royalty-free,
  17.  * nonexclusive right and license to deal in this software and
  18.  * documentation files (the "Software"), including without limitation the
  19.  * rights to use, copy, modify, merge, publish, distribute, sublicense,
  20.  * and/or sell copies of the Software, and to permit persons who receive
  21.  * copies from any such party to do so, with the only requirement being
  22.  * that this copyright notice remain intact.  This license includes without
  23.  * limitation a license to do the foregoing actions under any patents of
  24.  * the party supplying this software to the X Consortium.
  25.  */
  26.  
  27. /* 
  28.  *    FIG : Facility for Interactive Generation of figures
  29.  *
  30.  *    Copyright (c) 1985, 1988 by Supoj Sutanthavibul (supoj@sally.UTEXAS.EDU)
  31.  *    January 1985.
  32.  *    1st revision : August 1985.
  33.  *    2nd revision : March 1988.
  34.  *
  35.  *    %W%    %G%
  36. */
  37. #include <stdio.h>
  38. #include <ctype.h>
  39. #include <errno.h>
  40. #include "alloc.h"
  41. #include "fig2dev.h"
  42. #include "object.h"
  43. #include "../patchlevel.h"
  44.  
  45. #if defined(hpux) || defined(SYSV) || defined(SVR4)
  46. #define bzero(s,n) memset((s),'\0',(n))
  47. #endif
  48.  
  49. extern int            errno;
  50.  
  51. extern F_arrow        *make_arrow();
  52. extern char        *calloc();
  53. extern double         floor(), ceil();
  54.  
  55. static void         read_colordef();
  56. static F_ellipse    *read_ellipseobject();
  57. static F_line        *read_lineobject();
  58. static F_text        *read_textobject();
  59. static F_spline        *read_splineobject();
  60. static F_arc        *read_arcobject();
  61. static F_compound    *read_compoundobject();
  62.  
  63. #define            FILL_CONVERT(f) \
  64.                 ((v2_flag || (f) < WHITE_FILL) \
  65.                     ? (v30_flag? f: (f-1)) : 20 - ((f)-1)*5)
  66.  
  67. #define            BUF_SIZE        1024
  68.  
  69. User_color        user_colors[MAX_USR_COLS];
  70. int            user_col_indx[MAX_USR_COLS];
  71. int            num_usr_cols;
  72. char            buf[BUF_SIZE];
  73. int            line_no = 0;
  74. int            num_object;
  75. int            v2_flag;    /* Protocol V2.0 or higher */
  76. int            v21_flag;    /* Protocol V2.1 or higher */
  77. int            v30_flag;    /* Protocol V3.0 or higher */
  78. float            THICK_SCALE;    /* convert line thickness from screen res. */
  79.  
  80. read_fail_message(file, err)
  81. char    *file;
  82. int    err;
  83. {
  84.     extern char    *sys_errlist[];
  85.  
  86.     if (err == 0)        /* Successful read */
  87.         return;
  88. #if !defined(hpux) && !defined(SYSV) && !defined(SVR4)
  89.     else if (err == ENAMETOOLONG)
  90.         put_msg("File name \"%s\" is too long", file);
  91. #endif
  92.     else if (err == ENOENT)
  93.         put_msg("File \"%s\" does not exist", file);
  94.     else if (err == ENOTDIR)
  95.         put_msg("A name in the path \"%s\" is not a directory", file);
  96.     else if (err == EACCES)
  97.         put_msg("Read access to file \"%s\" is blocked", file);
  98.     else if (err == EISDIR)
  99.         put_msg("File \"%s\" is a directory", file);
  100.     else if (err == -2) {
  101.         put_msg("File \"%s\" is empty", file);
  102.         }
  103.     else if (err == -1) {
  104.         /* Format error; relevant error message is already delivered */
  105.         }
  106.     else
  107.         put_msg("File \"%s\" is not accessable; %s", file, sys_errlist[err]);
  108.     }
  109.  
  110. /**********************************************************
  111. Read_fig returns :
  112.  
  113.      0 : successful read.
  114.     -1 : File is in incorrect format
  115.     -2 : File is empty
  116. err_no : if file can not be read for various reasons
  117.  
  118. The resolution (ppi) and the cooridnate system (coord_sys) are
  119. stored in obj->nwcorner.x and obj->nwcorner.x respectively.
  120. **********************************************************/
  121.  
  122. read_fig(file_name, obj)
  123. char        *file_name;
  124. F_compound    *obj;
  125. {
  126.     FILE        *fp;
  127.  
  128.     init_pats_used();
  129.     if ((fp = fopen(file_name, "r")) == NULL)
  130.         return(errno);
  131.     else
  132.         return(readfp_fig(fp, obj));
  133.     }
  134.  
  135. readfp_fig(fp, obj)
  136. FILE    *fp;
  137. F_compound    *obj;
  138. {
  139.     char        c;
  140.     int        status;
  141.  
  142.     num_object = 0;
  143.     num_usr_cols = 0;
  144.     c = fgetc(fp);
  145.     if (feof(fp)) return(-2);
  146.     ungetc(c, fp);
  147.     bzero((char*)obj, COMOBJ_SIZE);
  148.     if (c == '#')
  149.         status = read_objects(fp, obj);
  150.     else
  151.         status = read_1_3_objects(fp, obj);
  152.     (void)fclose(fp);
  153.     return(status);
  154.     }
  155.     
  156. int
  157. read_objects(fp, obj)
  158. FILE        *fp;
  159. F_compound    *obj;
  160. {
  161.     F_ellipse    *e, *le = NULL;
  162.     F_line        *l, *ll = NULL;
  163.     F_text        *t, *lt = NULL;
  164.     F_spline    *s, *ls = NULL;
  165.     F_arc        *a, *la = NULL;
  166.     F_compound    *c, *lc = NULL;
  167.     int        object, ppi, coord_sys;
  168.  
  169.     bzero((char*)obj, COMOBJ_SIZE);
  170.     (void)fgets(buf, BUF_SIZE, fp);    /* get the version line */
  171.     if (strlen(buf) > 0)
  172.         buf[strlen(buf)-1] = '\0';    /* remove newline */
  173.  
  174.     /* v2_flag is for version 2 or higher */
  175.     v2_flag = (!strncmp(buf, "#FIG 2", 6) || !strncmp(buf, "#FIG 3", 6));
  176.     /* v21_flag is for version 2.1 or higher */
  177.     v21_flag = (!strncmp(buf, "#FIG 2.1", 8) || !strncmp(buf, "#FIG 3", 6));
  178.     /* version 2.2 was only beta - 3.0 is the official release (they are identical) */
  179.     v30_flag = (!strncmp(buf, "#FIG 3", 6) || !strncmp(buf, "#FIG 2.2", 8));
  180.     if (strncmp(&buf[5],VERSION,3) > 0) {
  181.         put_msg("Fig file format (%s) newer than this version of fig2dev (%s), exiting",
  182.             &buf[5],VERSION);
  183.         exit(1);
  184.     }
  185.  
  186.     if (v30_flag) {
  187.         /* read the orientation spec (landscape/portrait) */
  188.         line_no++;
  189.         if (get_line(fp) < 0) {
  190.         put_msg("File is truncated at landscape/portrait specification.");
  191.         return(-1);
  192.         }
  193.         /* but set only of the user didn't specify the orientation
  194.            on the command line */
  195.         if (!orientspec)
  196.         landscape = !strncasecmp(buf,"land",4);
  197.  
  198.         /* now read the metric/inches spec OR centering spec */
  199.         line_no++;
  200.         if (get_line(fp) < 0) {
  201.         put_msg("File is truncated at metric/inches or centering specification.");
  202.         return(-1);
  203.         }
  204.         if ((strncasecmp(buf,"center",6) == 0) || 
  205.         (strncasecmp(buf,"flush",5) == 0)) {
  206.         center = strncasecmp(buf,"flush",5);
  207.         /* now read metric/inches spec */
  208.         line_no++;
  209.         if (get_line(fp) < 0) {
  210.             put_msg("File is truncated at metric/inches specification.");
  211.             return(-1);
  212.         }
  213.         }
  214.         /* if metric, scale magnification to correct for xfig display error */
  215.         if (strncasecmp(buf,"metric",5)==0)
  216.         mag *= 80.0/76.2;
  217.     }
  218.  
  219.     line_no++;
  220.     /* now read for resolution and coord_sys */
  221.     if (get_line(fp) < 0) {
  222.         put_msg("File is truncated at resolution specification.");
  223.         return(-1);
  224.         }
  225.     if (sscanf(buf,"%d%d\n", &ppi, &coord_sys) != 2) {
  226.         put_msg("Incomplete resolution information at line %d", line_no);
  227.         return(-1);
  228.         }
  229.  
  230.     THICK_SCALE = ppi/80;    /* convert line thickness from screen resolution */
  231.     obj->nwcorner.x = ppi;
  232.     obj->nwcorner.y = coord_sys;
  233.     while (get_line(fp) > 0) {
  234.         if (sscanf(buf, "%d", &object) != 1) {
  235.         put_msg("Incorrect format at line %d", line_no);
  236.         return(-1);
  237.         }
  238.         switch (object) {
  239.         case O_COLOR_DEF:
  240.             read_colordef(fp);
  241.             if (num_object) {
  242.             put_msg("Color definitions must come before other objects (line %d).",
  243.                 line_no);
  244.             return (-1);
  245.             }
  246.             num_usr_cols++;
  247.             break;
  248.         case O_POLYLINE :
  249.             if ((l = read_lineobject(fp)) == NULL) 
  250.             return(-1);
  251.             if (ll)
  252.             ll = (ll->next = l);
  253.             else 
  254.             ll = obj->lines = l;
  255.             num_object++;
  256.             break;
  257.         case O_SPLINE :
  258.             if ((s = read_splineobject(fp)) == NULL) 
  259.             return(-1);
  260.             if (ls)
  261.             ls = (ls->next = s);
  262.             else 
  263.             ls = obj->splines = s;
  264.             num_object++;
  265.             break;
  266.         case O_ELLIPSE :
  267.             if ((e = read_ellipseobject()) == NULL) 
  268.             return(-1);
  269.             if (le)
  270.             le = (le->next = e);
  271.             else 
  272.             le = obj->ellipses = e;
  273.             num_object++;
  274.             break;
  275.         case O_ARC :
  276.             if ((a = read_arcobject(fp)) == NULL) 
  277.             return(-1);
  278.             if (la)
  279.             la = (la->next = a);
  280.             else 
  281.             la = obj->arcs = a;
  282.             num_object++;
  283.             break;
  284.         case O_TEXT :
  285.             if ((t = read_textobject(fp)) == NULL) 
  286.             return(-1);
  287.             if (lt)
  288.             lt = (lt->next = t);
  289.             else 
  290.             lt = obj->texts = t;
  291.             num_object++;
  292.             break;
  293.         case O_COMPOUND :
  294.             if ((c = read_compoundobject(fp)) == NULL) 
  295.             return(-1);
  296.             if (lc)
  297.             lc = (lc->next = c);
  298.             else 
  299.             lc = obj->compounds = c;
  300.             num_object++;
  301.             break;
  302.         default :
  303.             put_msg("Incorrect object code at line %d", line_no);
  304.             return(-1);
  305.         } /*  switch */
  306.         } /*  while */
  307.     if (feof(fp))
  308.         return(0);
  309.     else
  310.         return(errno);
  311.     } /*  read_objects */
  312.  
  313. static void
  314. read_colordef(fp)
  315.     FILE       *fp;
  316. { 
  317.     int            c,r,g,b;
  318.  
  319.     if ((sscanf(buf, "%*d %d #%02x%02x%02x", &c, &r, &g, &b) != 4) ||
  320.         (c < NUM_STD_COLS)) {
  321.     buf[strlen(buf)-1]='\0';    /* remove the newline */
  322.     put_msg("Invalid color definition: %s, setting to black (#00000).",buf);
  323.     r=g=b=0;
  324.     }
  325.     user_col_indx[num_usr_cols] = c;
  326.     user_colors[num_usr_cols].r = r;
  327.     user_colors[num_usr_cols].g = g;
  328.     user_colors[num_usr_cols].b = b;
  329. }
  330.  
  331. fix_color(color)
  332.     int            *color;
  333. {
  334.     int            i;
  335.     if (*color < NUM_STD_COLS)
  336.     return;
  337.     for (i=0; i<num_usr_cols; i++)
  338.     if (*color == user_col_indx[i]) {
  339.         *color = i+NUM_STD_COLS;
  340.         return;
  341.     }
  342.     put_msg("Cannot locate user color %d, using default color for line %d.",
  343.         *color,line_no);
  344.     *color = DEFAULT;
  345.     return;
  346. }
  347.  
  348. static F_arc *
  349. read_arcobject(fp)
  350. FILE    *fp;
  351. {
  352.     F_arc    *a;
  353.     int    n, fa, ba;
  354.     int    type, style;
  355.     double    thickness, wid, ht;
  356.  
  357.     if (NULL == (Arc_malloc(a))) {
  358.         put_msg(Err_mem);
  359.         return(NULL);
  360.         }
  361.     a->pen = 0;
  362.     a->fill_style = 0;
  363.     a->for_arrow = NULL;
  364.     a->back_arrow = NULL;
  365.     a->next = NULL;
  366.     if (v30_flag) {
  367.         n = sscanf(buf, "%*d%d%d%d%d%d%d%d%d%lf%d%d%d%d%lf%lf%d%d%d%d%d%d\n",
  368.         &a->type, &a->style, &a->thickness, 
  369.         &a->pen_color, &a->fill_color, &a->depth, &a->pen, &a->fill_style, 
  370.         &a->style_val, &a->cap_style,
  371.         &a->direction, &fa, &ba,
  372.         &a->center.x, &a->center.y, 
  373.         &a->point[0].x, &a->point[0].y, 
  374.         &a->point[1].x, &a->point[1].y, 
  375.         &a->point[2].x, &a->point[2].y);
  376.     } else {
  377.         n = sscanf(buf, "%*d%d%d%d%d%d%d%d%lf%d%d%d%lf%lf%d%d%d%d%d%d\n",
  378.         &a->type, &a->style, &a->thickness, 
  379.         &a->pen_color, &a->depth, &a->pen, &a->fill_style, 
  380.         &a->style_val, &a->direction, &fa, &ba,
  381.         &a->center.x, &a->center.y, 
  382.         &a->point[0].x, &a->point[0].y, 
  383.         &a->point[1].x, &a->point[1].y, 
  384.         &a->point[2].x, &a->point[2].y);
  385.         a->fill_color = a->pen_color;
  386.         a->cap_style = 0;        /* butt line cap */
  387.     }
  388.     if ((v30_flag && n != 21) || (!v30_flag && n != 19)) {
  389.         put_msg(Err_incomp, "arc", line_no);
  390.         free((char*)a);
  391.         return(NULL);
  392.         }
  393.     a->thickness *= THICK_SCALE;
  394.     a->fill_style = FILL_CONVERT(a->fill_style);
  395.     /* keep track if pattern is used */
  396.     note_pattern(a->fill_style);
  397.     fix_color(&a->pen_color);
  398.     fix_color(&a->fill_color);
  399.     skip_comment(fp);
  400.     if (fa) {
  401.         line_no++;
  402.         if (fscanf(fp, "%d%d%lf%lf%lf", &type, &style, &thickness, &wid, &ht) != 5) {
  403.         fprintf(stderr, Err_incomp, "arc", line_no);
  404.         return(NULL);
  405.         }
  406.         skip_line(fp);
  407.         a->for_arrow = make_arrow(type, style, thickness, wid, ht);
  408.         skip_comment(fp);
  409.         }
  410.     skip_comment(fp);
  411.     if (ba) {
  412.         line_no++;
  413.         if (fscanf(fp, "%d%d%lf%lf%lf", &type, &style, &thickness, &wid, &ht) != 5) {
  414.         fprintf(stderr, Err_incomp, "arc", line_no);
  415.         return(NULL);
  416.         }
  417.         skip_line(fp);
  418.         a->back_arrow = make_arrow(type, style, thickness, wid, ht);
  419.         }
  420.     return(a);
  421.     }
  422.  
  423. static F_compound *
  424. read_compoundobject(fp)
  425. FILE    *fp;
  426. {
  427.     F_arc        *a, *la = NULL;
  428.     F_ellipse    *e, *le = NULL;
  429.     F_line        *l, *ll = NULL;
  430.     F_spline    *s, *ls = NULL;
  431.     F_text        *t, *lt = NULL;
  432.     F_compound    *com, *c, *lc = NULL;
  433.     int        n, object;
  434.  
  435.     Compound_malloc(com);
  436.     com->arcs = NULL;
  437.     com->ellipses = NULL;
  438.     com->lines = NULL;
  439.     com->splines = NULL;
  440.     com->texts = NULL;
  441.     com->compounds = NULL;
  442.     com->next = NULL;
  443.     n = sscanf(buf, "%*d%d%d%d%d\n", &com->nwcorner.x, &com->nwcorner.y,
  444.         &com->secorner.x, &com->secorner.y);
  445.     if (n != 4) {
  446.         put_msg(Err_incomp, "compound", line_no);
  447.         free((char*)com);
  448.         return(NULL);
  449.         }
  450.     while (get_line(fp) > 0) {
  451.         if (sscanf(buf, "%d", &object) != 1) {
  452.         put_msg(Err_incomp, "compound", line_no);
  453.         free_compound(&com);
  454.         return(NULL);
  455.         }
  456.         switch (object) {
  457.         case O_POLYLINE :
  458.             if ((l = read_lineobject(fp)) == NULL) { 
  459.             free_line(&l);
  460.             return(NULL);
  461.             }
  462.             if (ll)
  463.             ll = (ll->next = l);
  464.             else 
  465.             ll = com->lines = l;
  466.             break;
  467.         case O_SPLINE :
  468.             if ((s = read_splineobject(fp)) == NULL) { 
  469.             free_spline(&s);
  470.             return(NULL);
  471.             }
  472.             if (ls)
  473.             ls = (ls->next = s);
  474.             else 
  475.             ls = com->splines = s;
  476.             break;
  477.         case O_ELLIPSE :
  478.             if ((e = read_ellipseobject()) == NULL) { 
  479.             free_ellipse(&e);
  480.             return(NULL);
  481.             }
  482.             if (le)
  483.             le = (le->next = e);
  484.             else 
  485.             le = com->ellipses = e;
  486.             break;
  487.         case O_ARC :
  488.             if ((a = read_arcobject(fp)) == NULL) { 
  489.             free_arc(&a);
  490.             return(NULL);
  491.             }
  492.             if (la)
  493.             la = (la->next = a);
  494.             else 
  495.             la = com->arcs = a;
  496.             break;
  497.         case O_TEXT :
  498.             if ((t = read_textobject(fp)) == NULL) { 
  499.             free_text(&t);
  500.             return(NULL);
  501.             }
  502.             if (lt)
  503.             lt = (lt->next = t);
  504.             else 
  505.             lt = com->texts = t;
  506.             break;
  507.         case O_COMPOUND :
  508.             if ((c = read_compoundobject(fp)) == NULL) { 
  509.             free_compound(&c);
  510.             return(NULL);
  511.             }
  512.             if (lc)
  513.             lc = (lc->next = c);
  514.             else 
  515.             lc = com->compounds = c;
  516.             break;
  517.         case O_END_COMPOUND :
  518.             return(com);
  519.         default :
  520.             put_msg("Wrong object code at line %d", line_no);
  521.             return(NULL);
  522.         } /*  switch */
  523.         }
  524.     if (feof(fp))
  525.         return(com);
  526.     else
  527.         return(NULL);
  528.     }
  529.  
  530. static F_ellipse *
  531. read_ellipseobject()
  532. {
  533.     F_ellipse    *e;
  534.     int        n;
  535.  
  536.     Ellipse_malloc(e);
  537.     e->fill_style = 0;
  538.     e->pen = 0;
  539.     e->next = NULL;
  540.     if (v30_flag) {
  541.         n = sscanf(buf, "%*d%d%d%d%d%d%d%d%d%lf%d%lf%d%d%d%d%d%d%d%d\n",
  542.         &e->type, &e->style, &e->thickness,
  543.         &e->pen_color, &e->fill_color, &e->depth, &e->pen, &e->fill_style,
  544.         &e->style_val, &e->direction, &e->angle,
  545.         &e->center.x, &e->center.y, 
  546.         &e->radiuses.x, &e->radiuses.y, 
  547.         &e->start.x, &e->start.y, 
  548.         &e->end.x, &e->end.y);
  549.     } else {
  550.         n = sscanf(buf, "%*d%d%d%d%d%d%d%d%lf%d%lf%d%d%d%d%d%d%d%d\n",
  551.         &e->type, &e->style, &e->thickness,
  552.         &e->pen_color, &e->depth, &e->pen, &e->fill_style,
  553.         &e->style_val, &e->direction, &e->angle,
  554.         &e->center.x, &e->center.y, 
  555.         &e->radiuses.x, &e->radiuses.y, 
  556.         &e->start.x, &e->start.y, 
  557.         &e->end.x, &e->end.y);
  558.         e->fill_color = e->pen_color;
  559.     }
  560.     if ((v30_flag && n != 19) || (!v30_flag && n != 18)) {
  561.         put_msg(Err_incomp, "ellipse", line_no);
  562.         free((char*)e);
  563.         return(NULL);
  564.         }
  565.     fix_color(&e->pen_color);
  566.     fix_color(&e->fill_color);
  567.     e->thickness *= THICK_SCALE;
  568.     e->fill_style = FILL_CONVERT(e->fill_style);
  569.     /* keep track if pattern is used */
  570.     note_pattern(e->fill_style);
  571.     return(e);
  572.     }
  573.  
  574. static F_line *
  575. read_lineobject(fp)
  576. FILE    *fp;
  577. {
  578.     F_line    *l;
  579.     F_point    *p, *q;
  580.     int    n, x, y, fa, ba;
  581.     int    type, style, radius_flag;
  582.     double    thickness, wid, ht;
  583.     int    npts;
  584.  
  585.     Line_malloc(l);
  586.     l->points = NULL;
  587.     l->pen = 0;
  588.     l->fill_style = 0;
  589.     l->for_arrow = NULL;
  590.     l->back_arrow = NULL;
  591.     l->next = NULL;
  592.     l->join_style = 0;
  593.     l->cap_style = 0;        /* butt line cap */
  594.  
  595.     sscanf(buf,"%*d%d",&l->type);    /* get the line type */
  596.  
  597.     radius_flag = v30_flag || v21_flag || (v2_flag && l->type == T_ARC_BOX);
  598.     if (radius_flag) {
  599.         if (v30_flag) {
  600.         n = sscanf(buf, "%*d%d%d%d%d%d%d%d%d%lf%d%d%d%d%d%d",
  601.         &l->type,&l->style,&l->thickness,&l->pen_color,&l->fill_color,
  602.         &l->depth,&l->pen,&l->fill_style,&l->style_val,
  603.         &l->join_style,&l->cap_style,
  604.         &l->radius,&fa,&ba,&npts);
  605.         } else {
  606.         n = sscanf(buf, "%*d%d%d%d%d%d%d%d%lf%d%d%d",
  607.         &l->type,&l->style,&l->thickness,&l->pen_color,
  608.         &l->depth,&l->pen,&l->fill_style,&l->style_val,&l->radius,&fa, &ba);
  609.         l->fill_color = l->pen_color;
  610.         }
  611.     }
  612.     /* old format uses pen for radius of arc-box corners */
  613.     else
  614.         {
  615.         n = sscanf(buf, "%*d%d%d%d%d%d%d%d%lf%d%d",
  616.             &l->type,&l->style,&l->thickness,&l->pen_color,
  617.             &l->depth,&l->pen,&l->fill_style,&l->style_val,&fa,&ba);
  618.         l->fill_color = l->pen_color;
  619.         if (l->type == T_ARC_BOX)
  620.         {
  621.         l->radius = (int) l->pen;
  622.         l->pen = 0;
  623.         }
  624.         else
  625.         l->radius = 0;
  626.         }
  627.     if ((!radius_flag && n!=10) ||
  628.          (radius_flag && ((!v30_flag && n!=11)||(v30_flag && n!=15)))) {
  629.         put_msg(Err_incomp, "line", line_no);
  630.         free((char*)l);
  631.         return(NULL);
  632.         }
  633.     l->radius *= THICK_SCALE;
  634.     l->thickness *= THICK_SCALE;
  635.     l->fill_style = FILL_CONVERT(l->fill_style);
  636.     /* keep track if pattern is used */
  637.     note_pattern(l->fill_style);
  638.     fix_color(&l->pen_color);
  639.     fix_color(&l->fill_color);
  640.     skip_comment(fp);
  641.     if (fa) {
  642.         line_no++;
  643.         if (fscanf(fp, "%d%d%lf%lf%lf", &type, &style, &thickness, &wid, &ht) != 5) {
  644.         fprintf(stderr, Err_incomp, "line", line_no);
  645.         return(NULL);
  646.         }
  647.         skip_line(fp);
  648.         l->for_arrow = make_arrow(type, style, thickness, wid, ht);
  649.         skip_comment(fp);
  650.         }
  651.     if (ba) {
  652.         line_no++;
  653.         if (fscanf(fp, "%d%d%lf%lf%lf", &type, &style, &thickness, &wid, &ht) != 5) {
  654.         fprintf(stderr, Err_incomp, "line", line_no);
  655.         return(NULL);
  656.         }
  657.         skip_line(fp);
  658.         l->back_arrow = make_arrow(type, style, thickness, wid, ht);
  659.         skip_comment(fp);
  660.         }
  661.         if (l->type == T_PIC_BOX) {
  662.         line_no++;
  663.         Pic_malloc(l->pic);
  664.         if (l->pic  == NULL) {
  665.             free((char *) l);
  666.             return (NULL);
  667.         }
  668.         if (fscanf(fp, "%d %s", &l->pic->flipped, l->pic->file) != 2) {
  669.                 put_msg(Err_incomp,
  670.                 "Picture object", line_no);
  671.                 fprintf(stderr, Err_incomp,
  672.                 "Picture object", line_no);
  673.             return (NULL);
  674.         }
  675.         } else
  676.         l->pic = NULL;
  677.  
  678.     if (NULL == (l->points = Point_malloc(p))) {
  679.         put_msg(Err_mem);
  680.         return(NULL);
  681.         }
  682.     p->next = NULL;
  683.     if (fscanf(fp, "%d%d", &p->x, &p->y) != 2) {
  684.         put_msg(Err_incomp, "line", line_no);
  685.         free_linestorage(l);
  686.         return(NULL);
  687.         }
  688.     if (!v30_flag)
  689.         npts = 1000000;
  690.     for (--npts; npts > 0; npts--) {
  691.         if (fscanf(fp, "%d%d", &x, &y) != 2) {
  692.         put_msg(Err_incomp, "line", line_no);
  693.         free_linestorage(l);
  694.         return(NULL);
  695.         }
  696.         if (!v30_flag && x == 9999) 
  697.         break;
  698.         if (NULL == (Point_malloc(q))) {
  699.         put_msg(Err_mem);
  700.         free_linestorage(l);
  701.         return(NULL);
  702.         }
  703.         q->x = x;
  704.         q->y = y;
  705.         q->next = NULL;
  706.         p->next = q;
  707.         p = q;
  708.         }
  709.     skip_line(fp);
  710.     return(l);
  711.     }
  712.  
  713. static F_spline *
  714. read_splineobject(fp)
  715. FILE    *fp;
  716. {
  717.     F_spline    *s;
  718.     F_point        *p, *q;
  719.     F_control    *cp, *cq;
  720.     int        c, n, x, y, fa, ba;
  721.     int        type, style, npts;
  722.     double        thickness, wid, ht;
  723.     double        lx, ly, rx, ry;
  724.  
  725.     Spline_malloc(s);
  726.     s->points = NULL;
  727.     s->controls = NULL;
  728.     s->pen = 0;
  729.     s->fill_style = 0;
  730.     s->for_arrow = NULL;
  731.     s->back_arrow = NULL;
  732.     s->next = NULL;
  733.  
  734.     if (v30_flag) {
  735.         n = sscanf(buf, "%*d%d%d%d%d%d%d%d%d%lf%d%d%d%d",
  736.             &s->type, &s->style, &s->thickness,
  737.         &s->pen_color, &s->fill_color,
  738.         &s->depth, &s->pen, &s->fill_style, &s->style_val,
  739.         &s->cap_style, &fa, &ba, &npts);
  740.     } else {
  741.         n = sscanf(buf, "%*d%d%d%d%d%d%d%d%lf%d%d",
  742.             &s->type, &s->style, &s->thickness, &s->pen_color,
  743.         &s->depth, &s->pen, &s->fill_style, &s->style_val, &fa, &ba);
  744.         s->fill_color = s->pen_color;
  745.         s->cap_style = 0;        /* butt line cap */
  746.     }
  747.     if ((v30_flag && n != 13) || (!v30_flag && n != 10)) {
  748.         put_msg(Err_incomp, "spline", line_no);
  749.         free((char*)s);
  750.         return(NULL);
  751.         }
  752.     s->thickness *= THICK_SCALE;
  753.     s->fill_style = FILL_CONVERT(s->fill_style);
  754.     /* keep track if pattern is used */
  755.     note_pattern(s->fill_style);
  756.     fix_color(&s->pen_color);
  757.     fix_color(&s->fill_color);
  758.     skip_comment(fp);
  759.     if (fa) {
  760.         line_no++;
  761.         if (fscanf(fp, "%d%d%lf%lf%lf", &type, &style, &thickness, &wid, &ht) != 5) {
  762.         fprintf(stderr, Err_incomp, "spline", line_no);
  763.         return(NULL);
  764.         }
  765.         skip_line(fp);
  766.         s->for_arrow = make_arrow(type, style, thickness, wid, ht);
  767.         skip_comment(fp);
  768.         }
  769.     if (ba) {
  770.         line_no++;
  771.         if (fscanf(fp, "%d%d%lf%lf%lf", &type, &style, &thickness, &wid, &ht) != 5) {
  772.         fprintf(stderr, Err_incomp, "spline", line_no);
  773.         return(NULL);
  774.         }
  775.         skip_line(fp);
  776.         s->back_arrow = make_arrow(type, style, thickness, wid, ht);
  777.         skip_comment(fp);
  778.         }
  779.  
  780.     /* Read points */
  781.     if ((n = fscanf(fp, "%d%d", &x, &y)) != 2) {
  782.         put_msg(Err_incomp, "spline", line_no);
  783.         free_splinestorage(s);
  784.         return(NULL);
  785.         };
  786.     if (NULL == (s->points = Point_malloc(p))) {
  787.         put_msg(Err_mem);
  788.         free_splinestorage(s);
  789.         return(NULL);
  790.         }
  791.     p->x = x; p->y = y;
  792.     c = 1;
  793.     if (!v30_flag)
  794.         npts = 1000000;
  795.     for (--npts; npts > 0; npts--) {
  796.         if (fscanf(fp, "%d%d", &x, &y) != 2) {
  797.         put_msg(Err_incomp, "spline", line_no);
  798.         p->next = NULL;
  799.         free_splinestorage(s);
  800.         return(NULL);
  801.         };
  802.         if (!v30_flag && x == 9999) 
  803.         break;
  804.         if (NULL == (Point_malloc(q))) {
  805.         put_msg(Err_mem);
  806.         free_splinestorage(s);
  807.         return(NULL);
  808.         }
  809.         q->x = x;
  810.         q->y = y;
  811.         p->next = q;
  812.         p = q;
  813.         c++;
  814.         }
  815.     p->next = NULL;
  816.     skip_line(fp);
  817.  
  818.     if (normal_spline(s)) return(s);
  819.  
  820.     skip_comment(fp);
  821.     /* Read controls */
  822.     if ((n = fscanf(fp, "%lf%lf%lf%lf", &lx, &ly, &rx, &ry)) != 4) {
  823.         put_msg(Err_incomp, "spline", line_no);
  824.         free_splinestorage(s);
  825.         return(NULL);
  826.         };
  827.     if (NULL == (s->controls = Control_malloc(cp))) {
  828.         put_msg(Err_mem);
  829.         free_splinestorage(s);
  830.         return(NULL);
  831.         }
  832.     cp->lx = lx; cp->ly = ly;
  833.     cp->rx = rx; cp->ry = ry;
  834.     while (--c) {
  835.         if (fscanf(fp, "%lf%lf%lf%lf", &lx, &ly, &rx, &ry) != 4) {
  836.         put_msg(Err_incomp, "spline", line_no);
  837.         cp->next = NULL;
  838.         free_splinestorage(s);
  839.         return(NULL);
  840.         };
  841.         if (NULL == (Control_malloc(cq))) {
  842.         put_msg(Err_mem);
  843.         cp->next = NULL;
  844.         free_splinestorage(s);
  845.         return(NULL);
  846.         }
  847.         cq->lx = lx; cq->ly = ly;
  848.         cq->rx = rx; cq->ry = ry;
  849.         cp->next = cq;
  850.         cp = cq;
  851.         }
  852.     cp->next = NULL;
  853.  
  854.     skip_line(fp);
  855.     return(s);
  856.     }
  857.  
  858. static F_text *
  859. read_textobject(fp)
  860. FILE    *fp;
  861. {
  862.     F_text    *t;
  863.     int    n, ignore = 0;
  864.     char    s[BUF_SIZE], s_temp[BUF_SIZE], junk[2];
  865.     int    more, len, l;
  866.  
  867.     Text_malloc(t);
  868.     t->font = 0;
  869.     t->size = 0.0;
  870.     t->next = NULL;
  871.  
  872. /* linux can't read 8-bit characters */
  873. #ifdef linux
  874.     {
  875.     char replaced;
  876.     int pos;
  877.     pos = 0;
  878.     len = strlen(buf);
  879.     while (((unsigned char) buf[pos] <= 'e' ) &&
  880.         ((unsigned char) buf[pos] >= ' ' ) && buf[pos] )
  881.             pos++;
  882.     replaced = buf[pos];
  883.     buf[pos]='f';
  884.     if (v30_flag) {    /* order of parms is more like other objects now */
  885.         n = sscanf(buf, "%*d%d%d%d%d%d%lf%lf%d%lf%lf%d%d%[^f]%[f]",
  886.         &t->type, &t->color, &t->depth, &t->pen,
  887.         &t->font, &t->size, &t->angle,
  888.         &t->flags, &t->height, &t->length,
  889.         &t->base_x, &t->base_y, s, junk);
  890.     } else {
  891.         n = sscanf(buf, "%*d%d%d%lf%d%d%d%lf%d%lf%lf%d%d%[^f]%[f]",
  892.         &t->type, &t->font, &t->size, &t->pen,
  893.         &t->color, &t->depth, &t->angle,
  894.         &t->flags, &t->height, &t->length,
  895.         &t->base_x, &t->base_y, s, junk);
  896.     }
  897.     n--;
  898.     if ( n < 13 ) {
  899.         put_msg(Err_incomp, "text", line_no);
  900.         free((char *) t);
  901.         return (NULL);
  902.        }
  903.     buf[pos]=replaced;
  904.     strcpy( s, buf+pos-strlen(s));
  905.     len=strlen(s);
  906.     if ( len && (s[len-1] ==  '\n') )
  907.         s[len-1]='\0';
  908.     len=strlen(s);
  909.     if (!v30_flag) {        /* if older version, remove the ^A */
  910.         if ( len && (s[len-1] ==  1) ) {
  911.         n++;
  912.         s[len-1]='\0';
  913.         }
  914.     }
  915.     }
  916.  
  917. #else
  918.     if (v30_flag) {    /* order of parms is more like other objects now,
  919.                string is now terminated with the literal '\001',
  920.                and 8-bit characters are represented as \xxx */
  921.  
  922.         n = sscanf(buf, "%*d%d%d%d%d%d%lf%lf%d%lf%lf%d%d%[^\n]",
  923.         &t->type, &t->color, &t->depth, &t->pen,
  924.         &t->font, &t->size, &t->angle,
  925.         &t->flags, &t->height, &t->length,
  926.         &t->base_x, &t->base_y, s, junk);
  927.     } else {
  928.         /* The text object is terminated by a CONTROL-A, so we read
  929.         everything up to the CONTROL-A and then read that character.
  930.         If we do not find the CONTROL-A on this line then this must
  931.         be a multi-line text object and we will have to read more. */
  932.  
  933.         n = sscanf(buf,"%*d%d%d%lf%d%d%d%lf%d%lf%lf%d%d%[^\1]%[\1]",
  934.         &t->type, &t->font, &t->size, &t->pen,
  935.         &t->color, &t->depth, &t->angle,
  936.         &t->flags, &t->height, &t->length, 
  937.         &t->base_x, &t->base_y, s, junk);
  938.     }
  939.     if ((n != 14) && (n != 13)) {
  940.       put_msg(Err_incomp, "text", line_no);
  941.       free((char*)t);
  942.        return(NULL);
  943.     }
  944. #endif
  945.     if (font_size) {
  946.         /* scale length/height of text by ratio of requested font size to actual size */
  947.         t->length = t->length * font_size/t->size;
  948.         t->height = t->height * font_size/t->size;
  949.         t->size = font_size;    /* and set to requested size */
  950.     }
  951.     if (t->size <= 0.0)
  952.         t->size = (float) DEFAULT_FONT_SIZE;
  953.     more = 0;
  954.     if (!v30_flag && n == 13)
  955.         more = 1;  /* in older xfig there is more if ^A wasn't found yet */
  956.     else if (v30_flag) {    /* in 3.0 there is more if \001 wasn't found */
  957.         len = strlen(s);
  958.         if ((strcmp(&s[len-4],"\\001") == 0) &&    /* if we find '\000' */
  959.             !(backslash_count(s, len-5) % 2)) {    /* and not '\\000' */
  960.             more = 0;                /* then there are no more lines */
  961.             s[len-4]='\0';            /* and get rid of the '\001' */
  962.         } else {
  963.         more = 1;
  964.         s[len++]='\n';            /* put back the end of line char */
  965.         s[len] = '\0';            /* and terminate it */
  966.         }
  967.     }
  968.     if (more) {
  969.     /* Read in the subsequent lines of the text if there is more than one. */
  970.       do {
  971.         fgets(buf, BUF_SIZE, fp);
  972.         line_no++;        /* As is done in get_line */
  973.         if (v30_flag) {
  974.         if (fgets(s_temp, BUF_SIZE, fp) == NULL)
  975.             break;
  976.         len = strlen(s_temp)-1;
  977.         if ((strncmp(&s_temp[len-4],"\\001",4) == 0) &&
  978.             !(backslash_count(s, len-5) % 2)) {
  979.             n=0;            /* found the '\001', set n to stop */
  980.             s_temp[len-4]='\0';    /* and get rid of the '\001' */
  981.         } else {
  982.             n=1;            /* keep going (more lines) */
  983.         }
  984.         } else {
  985.         if (fgets(buf, BUF_SIZE, fp) == NULL)
  986.             break;
  987.         n = sscanf(buf, "%[^\1]%[\1]", s_temp, junk);
  988.         }
  989.         /* Safety check */
  990.         if (strlen(s)+1 + strlen(s_temp)+1 > BUF_SIZE) {
  991.           /* Too many characters.  Ignore the rest. */
  992.           ignore = 1;
  993.         }
  994.         if (!ignore)
  995.           strcat(s, s_temp);
  996.       } while (n == 1);
  997.     }
  998.     if (v30_flag) {        /* now convert any \xxx to ascii characters */
  999.         if (strchr(s,'\\')) {
  1000.         int num;
  1001.         len = strlen(s);
  1002.         for (l=0,n=0; l < len; l++) {
  1003.             if (s[l]=='\\') {
  1004.             if (l < len && s[l+1] != '\\') {
  1005.                 if (sscanf(&s[l+1],"%3o",&num)!=1) {
  1006.                 put_msg("Error in parsing text string on line",line_no);
  1007.                 return(NULL);
  1008.                 }
  1009.                 buf[n++]= (unsigned char) num;    /* put char in */
  1010.                 l += 3;            /* skip over digits */
  1011.             } else {
  1012.                 buf[n++] = s[++l];        /* "\\" */
  1013.             }
  1014.             } else {
  1015.             buf[n++] = s[l];        /* ordinary character */
  1016.             }
  1017.         }
  1018.         buf[n]='\0';        /* terminate */
  1019.         strcpy(s,buf);        /* copy back to s */
  1020.         }
  1021.     }
  1022.     if (strlen(s) == 0) 
  1023.         (void)strcpy(s, " ");
  1024.     t->cstring = (char*)calloc((unsigned)(strlen(s)), sizeof(char));
  1025.     if (NULL == t->cstring) {
  1026.         put_msg(Err_mem);
  1027.         free((char*)t);
  1028.         return(NULL);
  1029.     }
  1030.     (void)strcpy(t->cstring, s+1);
  1031.  
  1032.     if (!v21_flag && (t->font == 0 || t->font == DEFAULT))
  1033.         t->flags = ((t->flags != DEFAULT) ? t->flags : 0)
  1034.                 | SPECIAL_TEXT;
  1035.  
  1036.     if (v2_flag && !v21_flag && !special_text(t)) 
  1037.         t->flags = ((t->flags != DEFAULT) ? t->flags : 0)
  1038.                 | PSFONT_TEXT;
  1039.  
  1040.     /* keep the font number reasonable */
  1041.     if (t->font > MAXFONT(t))
  1042.         t->font = MAXFONT(t);
  1043.     fix_color(&t->color);
  1044.     return(t);
  1045. }
  1046.  
  1047. /* akm 28/2/95 - count consecutive backslashes backwards */
  1048. int
  1049. backslash_count(cp, start)
  1050. char cp[];
  1051. int start;
  1052. {
  1053.   int i, count = 0;
  1054.  
  1055.   for(i=start; i>=0; i--) {
  1056.     if (cp[i] == '\\')
  1057.     count++;
  1058.     else
  1059.     break;
  1060.   }
  1061.   return count;
  1062. }
  1063.  
  1064. get_line(fp)
  1065. FILE    *fp;
  1066. {
  1067.     while (1) {
  1068.         if (NULL == fgets(buf, BUF_SIZE, fp)) {
  1069.         return(-1);
  1070.         }
  1071.         line_no++;
  1072.         if (*buf != '\n' && *buf != '#') 
  1073.         return(1);    /* Skip empty and comment lines */
  1074.         }
  1075. }
  1076.  
  1077. skip_comment(fp)
  1078. FILE    *fp;
  1079. {
  1080.     char c;
  1081.  
  1082.     while ((c = fgetc(fp)) == '#') 
  1083.         skip_line(fp);
  1084.     if (c != '#') 
  1085.         ungetc(c, fp);
  1086. }
  1087.  
  1088. skip_line(fp)
  1089. FILE    *fp;
  1090. {
  1091.     while (fgetc(fp) != '\n') {
  1092.         if (feof(fp)) 
  1093.         return;
  1094.     }
  1095. }
  1096.  
  1097. /* keep track which patterns are used (if any) */
  1098. note_pattern(fill_style)
  1099. int     fill_style;
  1100. {
  1101.     if (fill_style >= NUMSHADES+NUMTINTS) {
  1102.         pattern_used[fill_style-NUMSHADES-NUMTINTS] = TRUE;
  1103.         pats_used = TRUE;
  1104.     }
  1105. }
  1106.     
  1107. init_pats_used()
  1108. {
  1109.     int i;
  1110.     pats_used = FALSE;
  1111.     for (i=0; i<NUMPATTERNS; i++)
  1112.         pattern_used[i] = FALSE;
  1113. }
  1114.